home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 10 / AACD 10.iso / AACD / Games / MAME / src / vidhrdw / dynduke.c < prev    next >
C/C++ Source or Header  |  2000-04-04  |  7KB  |  237 lines
  1.  
  2. #include "driver.h"
  3. #include "vidhrdw/generic.h"
  4.  
  5. static struct tilemap *bg_layer,*fg_layer,*tx_layer;
  6. unsigned char *dynduke_back_data,*dynduke_fore_data,*dynduke_scroll_ram,*dynduke_control_ram;
  7.  
  8. static int flipscreen,back_bankbase,fore_bankbase,back_palbase;
  9. static int back_enable,fore_enable,sprite_enable;
  10.  
  11. /******************************************************************************/
  12.  
  13. WRITE_HANDLER( dynduke_paletteram_w )
  14. {
  15.     int r,g,b;
  16.  
  17.     paletteram[offset]=data;
  18.     data=paletteram[offset&0xffe]|(paletteram[offset|1]<<8);
  19.  
  20.     r = (data >> 0) & 0x0f;
  21.     g = (data >> 4) & 0x0f;
  22.     b = (data >> 8) & 0x0f;
  23.  
  24.     r = (r << 4) | r;
  25.     g = (g << 4) | g;
  26.     b = (b << 4) | b;
  27.  
  28.     palette_change_color(offset/2,r,g,b);
  29.  
  30.     /* This is a kludge to handle 5bpp graphics but 4bpp palette data */
  31.     if (offset<1024) {
  32.         palette_change_color(((offset&0x1f)/2) | (offset&0xffe0) | 2048,r,g,b);
  33.         palette_change_color(((offset&0x1f)/2) | (offset&0xffe0) | 2048 | 16,r,g,b);
  34.     }
  35. }
  36.  
  37. READ_HANDLER( dynduke_background_r )
  38. {
  39.     return dynduke_back_data[offset];
  40. }
  41.  
  42. READ_HANDLER( dynduke_foreground_r )
  43. {
  44.     return dynduke_fore_data[offset];
  45. }
  46.  
  47. WRITE_HANDLER( dynduke_background_w )
  48. {
  49.     dynduke_back_data[offset]=data;
  50.     tilemap_mark_tile_dirty(bg_layer,offset/2);
  51. }
  52.  
  53. WRITE_HANDLER( dynduke_foreground_w )
  54. {
  55.     dynduke_fore_data[offset]=data;
  56.     tilemap_mark_tile_dirty(fg_layer,offset/2);
  57. }
  58.  
  59. WRITE_HANDLER( dynduke_text_w )
  60. {
  61.     videoram[offset]=data;
  62.     tilemap_mark_tile_dirty(tx_layer,offset/2);
  63. }
  64.  
  65. static void get_bg_tile_info(int tile_index)
  66. {
  67.     int tile=dynduke_back_data[2*tile_index]+(dynduke_back_data[2*tile_index+1]<<8);
  68.     int color=tile >> 12;
  69.  
  70.     tile=tile&0xfff;
  71.  
  72.     SET_TILE_INFO(1,tile+back_bankbase,color+back_palbase)
  73. }
  74.  
  75. static void get_fg_tile_info(int tile_index)
  76. {
  77.     int tile=dynduke_fore_data[2*tile_index]+(dynduke_fore_data[2*tile_index+1]<<8);
  78.     int color=tile >> 12;
  79.  
  80.     tile=tile&0xfff;
  81.  
  82.     SET_TILE_INFO(2,tile+fore_bankbase,color)
  83. }
  84.  
  85. static void get_tx_tile_info(int tile_index)
  86. {
  87.     int tile=videoram[2*tile_index]+((videoram[2*tile_index+1]&0xc0)<<2);
  88.     int color=videoram[2*tile_index+1]&0xf;
  89.  
  90.     SET_TILE_INFO(0,tile,color)
  91. }
  92.  
  93. int dynduke_vh_start(void)
  94. {
  95.     bg_layer = tilemap_create(get_bg_tile_info,tilemap_scan_cols,TILEMAP_SPLIT,      16,16,32,32);
  96.     fg_layer = tilemap_create(get_fg_tile_info,tilemap_scan_cols,TILEMAP_TRANSPARENT,16,16,32,32);
  97.     tx_layer = tilemap_create(get_tx_tile_info,tilemap_scan_rows,TILEMAP_TRANSPARENT, 8, 8,32,32);
  98.  
  99.     bg_layer->transmask[0] = 0x0000ffff; /* 4bpp */
  100.     bg_layer->transmask[1] = 0xffff0000; /* The rest - 1bpp */
  101.  
  102.     fg_layer->transparent_pen = 15;
  103.     tx_layer->transparent_pen = 15;
  104.  
  105.     return 0;
  106. }
  107.  
  108. WRITE_HANDLER( dynduke_gfxbank_w )
  109. {
  110.     static int old_back,old_fore;
  111.  
  112.     if (data&0x01) back_bankbase=0x1000; else back_bankbase=0;
  113.     if (data&0x10) fore_bankbase=0x1000; else fore_bankbase=0;
  114.  
  115.     if (back_bankbase!=old_back)
  116.         tilemap_mark_all_tiles_dirty(bg_layer);
  117.     if (fore_bankbase!=old_fore)
  118.         tilemap_mark_all_tiles_dirty(fg_layer);
  119.  
  120.     old_back=back_bankbase;
  121.     old_fore=fore_bankbase;
  122. }
  123.  
  124. WRITE_HANDLER( dynduke_control_w )
  125. {
  126.     static int old_bpal;
  127.  
  128.     dynduke_control_ram[offset]=data;
  129.  
  130.     if (offset!=6) return;
  131.  
  132.     if (data&0x1) back_enable=0; else back_enable=1;
  133.     if (data&0x2) back_palbase=16; else back_palbase=0;
  134.     if (data&0x4) fore_enable=0; else fore_enable=1;
  135.     if (data&0x8) sprite_enable=0; else sprite_enable=1;
  136.  
  137.     if (back_palbase!=old_bpal)
  138.         tilemap_mark_all_tiles_dirty(bg_layer);
  139.  
  140.     old_bpal=back_palbase;
  141.     flipscreen=data&0x40;
  142.     tilemap_set_flip(ALL_TILEMAPS,flipscreen ? (TILEMAP_FLIPY | TILEMAP_FLIPX) : 0);
  143. }
  144.  
  145. static void draw_sprites(struct osd_bitmap *bitmap,int pri)
  146. {
  147.     int offs,fx,fy,x,y,color,sprite;
  148.  
  149.     if (!sprite_enable) return;
  150.  
  151.     for (offs = 0x1000-8;offs >= 0;offs -= 8)
  152.     {
  153.         /* Don't draw empty sprite table entries */
  154.         if (buffered_spriteram[offs+7]!=0xf) continue;
  155.         if (buffered_spriteram[offs+0]==0xf0f) continue;
  156.         if (((buffered_spriteram[offs+5]>>5)&3)!=pri) continue;
  157.  
  158.         fx= buffered_spriteram[offs+1]&0x20;
  159.         fy= buffered_spriteram[offs+1]&0x40;
  160.         y = buffered_spriteram[offs+0];
  161.         x = buffered_spriteram[offs+4];
  162.  
  163.         if (buffered_spriteram[offs+5]&1) x=0-(0x100-x);
  164.  
  165.         color = buffered_spriteram[offs+1]&0x1f;
  166.         sprite = buffered_spriteram[offs+2]+(buffered_spriteram[offs+3]<<8);
  167.         sprite &= 0x3fff;
  168.  
  169.         if (flipscreen) {
  170.             x=240-x;
  171.             y=240-y;
  172.             if (fx) fx=0; else fx=1;
  173.             if (fy) fy=0; else fy=1;
  174.         }
  175.  
  176.         drawgfx(bitmap,Machine->gfx[3],
  177.                 sprite,
  178.                 color,fx,fy,x,y,
  179.                 &Machine->drv->visible_area,TRANSPARENCY_PEN,15);
  180.     }
  181. }
  182.  
  183. void dynduke_vh_screenrefresh(struct osd_bitmap *bitmap,int full_refresh)
  184. {
  185.     int color,offs,sprite;
  186.     int colmask[32],i,pal_base;
  187.  
  188.     /* Setup the tilemaps */
  189.     tilemap_set_scrolly( bg_layer,0, ((dynduke_scroll_ram[0x02]&0x30)<<4)+((dynduke_scroll_ram[0x04]&0x7f)<<1)+((dynduke_scroll_ram[0x04]&0x80)>>7) );
  190.     tilemap_set_scrollx( bg_layer,0, ((dynduke_scroll_ram[0x12]&0x30)<<4)+((dynduke_scroll_ram[0x14]&0x7f)<<1)+((dynduke_scroll_ram[0x14]&0x80)>>7) );
  191.     tilemap_set_scrolly( fg_layer,0, ((dynduke_scroll_ram[0x22]&0x30)<<4)+((dynduke_scroll_ram[0x24]&0x7f)<<1)+((dynduke_scroll_ram[0x24]&0x80)>>7) );
  192.     tilemap_set_scrollx( fg_layer,0, ((dynduke_scroll_ram[0x32]&0x30)<<4)+((dynduke_scroll_ram[0x34]&0x7f)<<1)+((dynduke_scroll_ram[0x34]&0x80)>>7) );
  193.     tilemap_set_enable( bg_layer,back_enable);
  194.     tilemap_set_enable( fg_layer,fore_enable);
  195.     tilemap_update(ALL_TILEMAPS);
  196.  
  197.     /* Build the dynamic palette */
  198.     palette_init_used_colors();
  199.  
  200.     /* Sprites */
  201.     pal_base = Machine->drv->gfxdecodeinfo[3].color_codes_start;
  202.     for (color = 0;color < 32;color++) colmask[color] = 0;
  203.     for (offs = 0;offs <0x1000;offs += 8)
  204.     {
  205.         color = spriteram[offs+1]&0x1f;
  206.         sprite = buffered_spriteram[offs+2]+(buffered_spriteram[offs+3]<<8);
  207.         sprite &= 0x3fff;
  208.         colmask[color] |= Machine->gfx[3]->pen_usage[sprite];
  209.     }
  210.     for (color = 0;color < 32;color++)
  211.     {
  212.         for (i = 0;i < 15;i++)
  213.         {
  214.             if (colmask[color] & (1 << i))
  215.                 palette_used_colors[pal_base + 16 * color + i] = PALETTE_COLOR_USED;
  216.         }
  217.     }
  218.  
  219.     if (palette_recalc())
  220.         tilemap_mark_all_pixels_dirty(ALL_TILEMAPS);
  221.  
  222.     tilemap_render(ALL_TILEMAPS);
  223.  
  224.     if (back_enable)
  225.         tilemap_draw(bitmap,bg_layer,TILEMAP_BACK);
  226.     else
  227.         fillbitmap(bitmap,palette_transparent_pen,&Machine->drv->visible_area);
  228.  
  229.     draw_sprites(bitmap,0); /* Untested: does anything use it? Could be behind background */
  230.     draw_sprites(bitmap,1);
  231.     tilemap_draw(bitmap,bg_layer,TILEMAP_FRONT);
  232.     draw_sprites(bitmap,2);
  233.     tilemap_draw(bitmap,fg_layer,0);
  234.     draw_sprites(bitmap,3);
  235.     tilemap_draw(bitmap,tx_layer,0);
  236. }
  237.